Reiniciar R
library(tidyverse)
library(openxlsx)
library(ggthemes)
library(fs)
Un loop es una estructura de código que nos permite aplicar iterativamente un mismo conjunto de comandos, variando el valor de una variable. Por ejemplo:
for(i in 1:10){
print(i^2)
}
[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36
[1] 49
[1] 64
[1] 81
[1] 100
Esto se lee como : “Recorre cada uno de los valores (i) del vector numérico 1 a 10, y para cada uno de ellos imprimí el cuadrado (i^2)”.
Uno puede especificar la palabra que desee que tomé cada uno de los valores que debe tomar. En el ejemplo anterior fue i, pero bien podría ser la “Valores”
for(Valores in 1:10){
print(Valores^2)
}
[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36
[1] 49
[1] 64
[1] 81
[1] 100
Un loop puede iterar sobre cualquier tipo de vector, independientemente de lo que contenga.
Los loops son una estructura básica que existen en cualquier lenguaje de programación. En R no recomendamos abusar de ellos porque hacen que el código sea más lento.
Las estructuras condiconales nos permiten ejecutar una porción de código en caso de que cumplan una condición lógica
Su funcionamiento es el siguiente:
if(condicion){codigo a ejecutar si se cumple la condición}
if( 2+2 == 4){
print("Menos Mal")
}
[1] "Menos Mal"
if( 2+2 == 148.24){
print("R, tenemos un problema")
}
La función if_else() sirve para crear o modificar dicotómicamente un objeto/variable/vector a partir del cumplimiento de una o más condiciones lógicas.
Su funcionamiento es el siguiente:
if_else(condicion,función a aplicar si se cumple la condición,función a aplicar si no se cumple la condición)
if_else(2+2==4, true = "Joya",false = "Error")
[1] "Joya"
La creación de funciones propias nos permite automatizar todas aquellas partes del código que se repiten mucho. Una vez diseñadas, funcionan igual que cualquier comando.
Por ejemplo, podemos definir la suma de dos elementos como
suma <- function(valor1, valor2) {
valor1+valor2
}
suma(5,6)
[1] 11
Obviamente las funciones no son sólo para variables numéricas. Por ejemplo, podemos pegar dos strings con una flecha en el medio
funcion_prueba <- function(parametro1,parametro2) {
paste(parametro1, parametro2, sep = " <--> ")
}
funcion_prueba(parametro1 = "A ver", parametro2 = "Que pasa")
[1] "A ver <--> Que pasa"
También podemos asignar un valor por default para los parametros en caso de que el usuario no defina su valor al utilizar la función.
Otra_funcion_prueba <- function(parametro1 ,parametro2 = "String default") {
paste(parametro1, parametro2, sep = " <--> ")
}
Otra_funcion_prueba(parametro1 = "Valor 1 ")
[1] "Valor 1 <--> String default"
Las funciones que creamos nosotros permanecen en el ambiente de R temporariamente. Cuando removemos los objetos del ambiente, la función deja de existir. Por ende, debemos incorporarla en cada uno de los scripts en la cual la necesitemos. Una buena práctica, es incorporar nuestras funciones útiles al comienzo de cada script junto a la carga de las librerías.
Vale mencionar que lo que ocurre en una función, queda en la función excepto que explícitamente pidamos que devuelva el resultado, con el comando print().
Las funciones siempre devuelven el último objeto que se crea en ellas, o si explicitamente se utiliza el comando return()
Funciones anónimas
Son funciones a las cuales no les asignamos un nombre. Esto suele ser útil para hacer funciones pequeñas dentro de otras funciones o estructuras más complejas.
(function(x) x*2)(10)
[1] 20
MAP es la forma tidy de hacer loops. Además de ser más prolijo el código, es mucho más eficiente.
La función map toma un input, una función para aplicar, y alguna otra cosa (por ejemplo parametros que necesite la función)
Usamos map2 cuando tenemos que pasar dos input, que se aplican sobre una función:
Si tenemos más de dos…
Por ejemplo. Si queremos utilizar la función prueba sobre los datos del dataframe ABC_123
ABC_123 <- data.frame(Letras = LETTERS[1:20],Num = 1:20)
funcion_prueba
function(parametro1,parametro2) {
paste(parametro1, parametro2, sep = " <--> ")
}
Si el resultado que queremos es que junte cada fila, necesitamos pasarle dos parámetros: utilizamos map2(), Noten que la función se le pasa a map() sin paréntesis ni argumentos.
resultado <- map2(.x = ABC_123$Letras, .y = ABC_123$Num,.f = funcion_prueba)
resultado[1:3]
[[1]]
[1] "A <--> 1"
[[2]]
[1] "B <--> 2"
[[3]]
[1] "C <--> 3"
La salida de los map() es una lista, no un vector, por lo que si lo metemos dentro de un dataframe se vería así:
ABC_123 %>%
mutate(resultado= map2(.x = Letras,.y = Num,.f = funcion_prueba))
Al ponerlo dentro del dataframe desarma la lista y guarda cada elemento por separado. La magia de eso es que podemos guardar cualquier cosa en el dataframe no sólo valores, sino también listas, funciones, dataframes, etc.
Si queremos recuperar los valores originales en este caso podemos usar unlist()
# Recuperamos los tres primeros elementos de la lista resultados
resultado[1:3] %>% unlist()
[1] "A <--> 1" "B <--> 2" "C <--> 3"
# Recuperamos el elemento de la lista para cada par letra-numero (cada fila)
ABC_123 %>%
mutate(resultado= unlist(map2(.x = Letras,.y = Num,.f = funcion_prueba)))
Si lo que queríamos era que la función nos haga todas las combinaciones de letras y número, entonces lo que necesitamos es pasarle el segúndo parametro como algo fijo, poniendolo después de la función.
Notemos que estamos utilizando map() que toma un único input, en lugar de map2()
#Combinacion de todas las letras con todos los numeros
map(.x = ABC_123$Letras,.f = funcion_prueba,ABC_123$Num)[1:2]
[[1]]
[1] "A <--> 1" "A <--> 2" "A <--> 3" "A <--> 4" "A <--> 5" "A <--> 6" "A <--> 7" "A <--> 8" "A <--> 9"
[10] "A <--> 10" "A <--> 11" "A <--> 12" "A <--> 13" "A <--> 14" "A <--> 15" "A <--> 16" "A <--> 17" "A <--> 18"
[19] "A <--> 19" "A <--> 20"
[[2]]
[1] "B <--> 1" "B <--> 2" "B <--> 3" "B <--> 4" "B <--> 5" "B <--> 6" "B <--> 7" "B <--> 8" "B <--> 9"
[10] "B <--> 10" "B <--> 11" "B <--> 12" "B <--> 13" "B <--> 14" "B <--> 15" "B <--> 16" "B <--> 17" "B <--> 18"
[19] "B <--> 19" "B <--> 20"
En este caso, el map itera sobre cada elemento de letras, y para cada elemento i hace funcion_prueba(i,ABC$Num) y guarda el resultado en la lista
Si lo queremos meter en el dataframe:
# Asignar resultado al dataframe
ABC_123 %>%
mutate(resultado= map(Letras,funcion_prueba,Num))
Ahora cada fila tiene una lista de 20 elementos guardado en la columna resultado
No es necesario que definamos la función de antemano. Podemos usar funciones implícitas
# Calculamos el cuadrado de cada elemento
map_dbl(.x = c(1:10), .f = function(x) x^2)
[1] 1 4 9 16 25 36 49 64 81 100
# Calculamos el producto para los elementos x e y
map2_dbl(.x = c(1:10),.y = c(11:20),.f = function(x,y) x*y)
[1] 11 24 39 56 75 96 119 144 171 200
Incluso más conciso que las funciones implíictas son las funciones lambda donde definimos las variables como .x .y, etc. La flexibilidad de estas expresiones es limitada, pero puede ser útil en algunos casos.
# Calculamos el cuadrado de cada elemento
map_dbl(.x = c(1:10),.f = ~.x^2)
[1] 1 4 9 16 25 36 49 64 81 100
# Calculamos el producto para los elementos x e y
map2_dbl(.x = c(1:10),.y = c(11:20),.f = ~.x*.y)
[1] 11 24 39 56 75 96 119 144 171 200
Lo primero que necesitamos es definir un vector o lista sobre el que iterar.
Por ejemplo, podemos armar un vector con los path a las bases individuales, con el comando fs::dir_ls. Se le especifica el path donde buscar los archivos y en este caso una expresion regular regexp para que devuelva aquellos archivos que coinciden con la misma.
# Buscamos en el path aquellos aquellos archivos que matchean a la expresion regular
bases_individuales_path <- dir_ls(path = '../Fuentes/', regexp= 'individual')
bases_individuales_path
[01;32m../Fuentes/usu_individual_t117.txt[0m [01;32m../Fuentes/usu_individual_t216.txt[0m [01;32m../Fuentes/usu_individual_t316.txt[0m
[01;32m../Fuentes/usu_individual_t416.txt[0m
Luego, como en la función que usamos para leer las bases definimos muchos parametros, nos podemos armar una función wrapper que sólo necesite un parámetro, y que simplifique la escritura del map.
# Leer la base de EPH tomando como argumento el file_path
leer_base_eph <- function(path) {
# Lectura de archivo
read.table(path,sep=";", dec=",", header = TRUE, fill = TRUE) %>%
# Seleccion de variables relevantes
select(ANO4,TRIMESTRE,REGION,P21,CH04, CH06)
}
# Leer a un dataframe las tablas especificadas en el vector de bases individuales
bases_df <- tibble(bases_individuales_path) %>%
mutate(base = map(.x = bases_individuales_path, .f = leer_base_eph))
bases_df
El resultado es un dataframe donde la columna base tiene en cada fila otro dataframe con la base de la EPH de ese período. Esto es lo que llamamos un nested DF o dataframe anidado.
Si queremos abrir (“desanidar”) estas dataframes anidados usamos el comando unnest()
# Desanidamos el dataframe
bases_df <- bases_df %>% unnest()
bases_df
¿Qué pasa si los DF que tenemos nesteados no tienen la misma cantidad de columnas?
Esto mismo lo podemos usar para fragmentar el dataset por alguna variable, con la funcion group_by()
bases_df %>%
# Agrupar por region
group_by(REGION) %>%
# Anidar
nest()
Así, para cada región tenemos un DF.
¿ De qué sirve todo esto?
No todo en la vida es un Dataframe. Hay estucturas de datos que no se pueden normalizar a filas y columnas. En esos casos recurríamos tradicionalmente a los loops. Con MAP podemos tener los elementos agrupados en un sólo objeto y aún conservar sus formas diferentes.
Si bien no nos vamos a meter en el detalle del modelo lineal en este encuentro, es útil usarlo como ejemplo de lo que podemos hacer con MAP.
Planteamos el modelo \[ P21 = \beta_0 + \beta_1*CH04 + \beta_2*CH06 \]
Es un modelo que explica el ingreso (P21) en funcion del sexo (CH04) y edad (CH06)
# Calculamos una regresion lineal sobre el dataset que tiene todas las observaciones de EPH
lmfit <- lm(P21~factor(CH04)+CH06,data = bases_df)
# Resumen del modelo
summary(lmfit)
Call:
lm(formula = P21 ~ factor(CH04) + CH06, data = bases_df)
Residuals:
Min 1Q Median 3Q Max
-8449 -3631 -1938 705 393616
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 2599.1101 29.0732 89.40 <2e-16 ***
factor(CH04)2 -2250.9637 28.3026 -79.53 <2e-16 ***
CH06 57.3490 0.6347 90.35 <2e-16 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
Residual standard error: 6858 on 236187 degrees of freedom
Multiple R-squared: 0.05449, Adjusted R-squared: 0.05448
F-statistic: 6805 on 2 and 236187 DF, p-value: < 2.2e-16
(al final de la clase podemos charlar sobre los resultados)
De forma Tidy, la librería broom nos da los resultados sobre los coeficientes en un DF.
broom::tidy(lmfit)
Si lo queremos hacer por region
resultados <- tibble()
for (region in unique(bases_df$REGION)) {
# Creamos un dataset por region
data <- bases_df %>%
filter(REGION==region)
# Calcular el modelo lineal
lmfit <- lm(P21~factor(CH04)+CH06,data = data)
# Guardar los resultados de los coeficientes
lmtidy <- broom::tidy(lmfit)
# Asignamos la variable region
lmtidy$region <- region
# Unimos los dataframes
resultados <- bind_rows(resultados,lmtidy)
}
resultados
Primero me armo una funcion que me simplifica el codigo. La funcion nos devuelve la informacion de los coeficientes del modelo lineal calculado sobre el dataframe porcion
fun<-function(porcion,grupo) { broom::tidy(lm(P21~factor(CH04)+CH06,data = porcion))}
bases_df_lm <- bases_df %>%
# Agrupamos por region
group_by(REGION) %>%
# Anidamos
nest() %>%
# Creamos una columna que tenga el dataframe como resultado de la funcion
mutate(lm = map(data,fun))
bases_df_lm
# Desanidamos por la variable lm
bases_df_lm %>%
unnest(lm)
O incluso más facil, utilizando group_modify (que es un atajo que solo acepta DF)
bases_df %>%
group_by(REGION) %>%
group_modify(fun)
Pero MAP sirve para operar con cualquier objeto de R.
Por ejemplo podemos guardar el objeto S3:lm que es la regresion lineal entrenada. Ese objeto no es ni un vector, ni una lista, ni un DF. No es una estructura de datos, sino que es algo distinto, con propiedades como predict() para predecir, el summary() que vimos, etc.
# La funcion calcula el modelo lineal sobre cada porcion de datos
fun<-function(porcion,grupo) { lm(P21~factor(CH04)+CH06,data = porcion)}
bases_df %>%
# Agrupar por region
group_by(REGION) %>%
# Anidar
nest() %>%
# Calcular el modelo lineal
mutate(lm = map(data,fun))